```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>ArrayList删除操作深度解析</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.6;
        }
        .hero {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        }
        .card {
            transition: all 0.3s ease;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        }
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 20px rgba(0, 0, 0, 0.1);
        }
        .code-block {
            background-color: #f8f9fa;
            border-left: 4px solid #667eea;
        }
        .section-title {
            position: relative;
            padding-bottom: 0.5rem;
        }
        .section-title:after {
            content: "";
            position: absolute;
            bottom: 0;
            left: 0;
            width: 50px;
            height: 3px;
            background: linear-gradient(to right, #667eea, #764ba2);
        }
        .footer-link:hover {
            color: #a0aec0;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero text-white py-20 px-4">
        <div class="container mx-auto max-w-5xl">
            <div class="flex flex-col items-center text-center">
                <h1 class="text-4xl md:text-5xl font-bold mb-4">ArrayList删除操作深度解析</h1>
                <p class="text-xl md:text-2xl mb-8 max-w-3xl">探索Java集合框架中最常用的ArrayList及其删除操作背后的原理与性能优化</p>
                <div class="flex space-x-4">
                    <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full"><i class="fas fa-clock mr-2"></i>阅读时间: 8分钟</span>
                    <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full"><i class="fas fa-tags mr-2"></i>Java, 数据结构, 性能优化</span>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="container mx-auto max-w-5xl px-4 py-12">
        <!-- Introduction -->
        <section class="mb-16">
            <div class="bg-white rounded-xl p-8 card">
                <p class="text-lg text-gray-700 leading-relaxed">
                    ArrayList是Java集合框架中最常用的数据结构之一，但其删除操作在特定场景下可能成为性能瓶颈。
                    本文将深入分析ArrayList的三种主要删除方法，揭示其底层实现原理，并提供性能优化的实用建议。
                </p>
            </div>
        </section>

        <!-- Key Insight -->
        <section class="mb-16">
            <div class="bg-indigo-50 border-l-4 border-indigo-500 p-6 rounded-r-lg">
                <div class="flex items-start">
                    <div class="flex-shrink-0 text-indigo-600">
                        <i class="fas fa-lightbulb text-2xl"></i>
                    </div>
                    <div class="ml-4">
                        <h3 class="text-lg font-semibold text-gray-800">核心洞察</h3>
                        <p class="mt-2 text-gray-700">
                            ArrayList的删除操作主要影响性能的因素是元素的移动，尤其是在中间位置的删除。
                            为了优化性能，开发者可以考虑使用其他更适合频繁删除操作的数据结构，如LinkedList，
                            或根据具体的使用场景调整操作策略。
                        </p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Method Cards -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 section-title">删除元素的方法</h2>
            <div class="grid md:grid-cols-3 gap-6">
                <!-- Method 1 -->
                <div class="bg-white rounded-lg overflow-hidden shadow-md card">
                    <div class="p-6">
                        <div class="flex items-center mb-4">
                            <div class="bg-indigo-100 p-3 rounded-full mr-4">
                                <i class="fas fa-list-ol text-indigo-600"></i>
                            </div>
                            <h3 class="text-xl font-semibold">remove(int index)</h3>
                        </div>
                        <p class="text-gray-600 mb-4">删除指定索引位置的元素</p>
                        <ul class="space-y-2 text-gray-700">
                            <li class="flex items-start">
                                <i class="fas fa-check text-indigo-500 mt-1 mr-2"></i>
                                <span>验证索引有效性</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check text-indigo-500 mt-1 mr-2"></i>
                                <span>删除元素并移动后续元素</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check text-indigo-500 mt-1 mr-2"></i>
                                <span>时间复杂度: O(n)</span>
                            </li>
                        </ul>
                    </div>
                </div>

                <!-- Method 2 -->
                <div class="bg-white rounded-lg overflow-hidden shadow-md card">
                    <div class="p-6">
                        <div class="flex items-center mb-4">
                            <div class="bg-blue-100 p-3 rounded-full mr-4">
                                <i class="fas fa-search text-blue-600"></i>
                            </div>
                            <h3 class="text-xl font-semibold">remove(Object o)</h3>
                        </div>
                        <p class="text-gray-600 mb-4">删除指定对象的元素</p>
                        <ul class="space-y-2 text-gray-700">
                            <li class="flex items-start">
                                <i class="fas fa-check text-blue-500 mt-1 mr-2"></i>
                                <span>遍历查找匹配对象</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check text-blue-500 mt-1 mr-2"></i>
                                <span>删除元素并移动后续元素</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check text-blue-500 mt-1 mr-2"></i>
                                <span>时间复杂度: O(n)</span>
                            </li>
                        </ul>
                    </div>
                </div>

                <!-- Method 3 -->
                <div class="bg-white rounded-lg overflow-hidden shadow-md card">
                    <div class="p-6">
                        <div class="flex items-center mb-4">
                            <div class="bg-purple-100 p-3 rounded-full mr-4">
                                <i class="fas fa-broom text-purple-600"></i>
                            </div>
                            <h3 class="text-xl font-semibold">clear()</h3>
                        </div>
                        <p class="text-gray-600 mb-4">清空所有元素</p>
                        <ul class="space-y-2 text-gray-700">
                            <li class="flex items-start">
                                <i class="fas fa-check text-purple-500 mt-1 mr-2"></i>
                                <span>将所有元素引用置为null</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check text-purple-500 mt-1 mr-2"></i>
                                <span>size设置为0</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check text-purple-500 mt-1 mr-2"></i>
                                <span>时间复杂度: O(n)</span>
                            </li>
                        </ul>
                    </div>
                </div>
            </div>
        </section>

        <!-- Detailed Explanation -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 section-title">方法详解</h2>

            <!-- Method 1 Details -->
            <div class="mb-12">
                <h3 class="text-2xl font-semibold mb-4 text-indigo-700">1. 删除指定索引的元素 (remove(int index) 方法)</h3>
                <div class="bg-white rounded-lg overflow-hidden shadow-md p-6 mb-6 card">
                    <h4 class="text-lg font-semibold mb-3 text-gray-800">操作过程</h4>
                    <ul class="list-disc pl-6 space-y-2 text-gray-700">
                        <li><strong>验证索引有效性</strong>：方法首先会检查给定的索引是否在有效范围内（即索引值在 0 到 size-1 之间）。</li>
                        <li><strong>删除元素</strong>：如果索引有效，将删除索引处的元素。</li>
                        <li><strong>移动后续元素</strong>：从被删除的位置开始，所有后续元素将向左移动一位，以填补空缺。这是一个 O(n) 操作，其中 n 是从删除位置到数组末尾的距离。</li>
                        <li><strong>调整大小</strong>：将 size 减 1，表示删除操作后 ArrayList 中的元素数量减少了。</li>
                    </ul>
                </div>
                <div class="bg-white rounded-lg overflow-hidden shadow-md p-6 mb-6 card">
                    <h4 class="text-lg font-semibold mb-3 text-gray-800">性能影响</h4>
                    <ul class="list-disc pl-6 space-y-2 text-gray-700">
                        <li><strong>时间复杂度</strong>：O(n)，由于需要移动元素。</li>
                        <li><strong>空间复杂度</strong>：O(1)，删除操作不会影响 ArrayList 的底层数组的空间分配。</li>
                    </ul>
                </div>
                <div class="bg-gray-800 rounded-lg overflow-hidden">
                    <div class="flex items-center px-4 py-2 bg-gray-700 text-gray-300">
                        <div class="w-3 h-3 rounded-full bg-red-500 mr-2"></div>
                        <div class="w-3 h-3 rounded-full bg-yellow-500 mr-2"></div>
                        <div class="w-3 h-3 rounded-full bg-green-500 mr-2"></div>
                        <span class="text-sm ml-2">Java</span>
                    </div>
                    <pre class="p-4 text-gray-200 overflow-x-auto"><code class="language-java">ArrayList&lt;String&gt; list = new ArrayList&lt;&gt;(Arrays.asList("a", "b", "c", "d"));
list.remove(2); // 删除索引为2的元素，即 "c"
System.out.println(list); // 输出 [a, b, d]</code></pre>
                </div>
            </div>

            <!-- Method 2 Details -->
            <div class="mb-12">
                <h3 class="text-2xl font-semibold mb-4 text-blue-700">2. 删除指定对象的元素 (remove(Object o) 方法)</h3>
                <div class="bg-white rounded-lg overflow-hidden shadow-md p-6 mb-6 card">
                    <h4 class="text-lg font-semibold mb-3 text-gray-800">操作过程</h4>
                    <ul class="list-disc pl-6 space-y-2 text-gray-700">
                        <li><strong>查找对象</strong>：方法会遍历 ArrayList，查找第一个匹配给定对象的元素。</li>
                        <li><strong>删除元素</strong>：如果找到匹配的元素，将其从 ArrayList 中删除。</li>
                        <li><strong>移动后续元素</strong>：与删除索引的元素类似，找到元素后需要将后续元素向左移动一位，以填补空缺。</li>
                        <li><strong>调整大小</strong>：将 size 减 1。</li>
                    </ul>
                </div>
                <div class="bg-white rounded-lg overflow-hidden shadow-md p-6 mb-6 card">
                    <h4 class="text-lg font-semibold mb-3 text-gray-800">性能影响</h4>
                    <ul class="list-disc pl-6 space-y-2 text-gray-700">
                        <li><strong>时间复杂度</strong>：O(n)，查找元素和移动元素的操作都需要线性时间。</li>
                        <li><strong>空间复杂度</strong>：O(1)，删除操作不会影响 ArrayList 的底层数组的空间分配。</li>
                    </ul>
                </div>
                <div class="bg-gray-800 rounded-lg overflow-hidden">
                    <div class="flex items-center px-4 py-2 bg-gray-700 text-gray-300">
                        <div class="w-3 h-3 rounded-full bg-red-500 mr-2"></div>
                        <div class="w-3 h-3 rounded-full bg-yellow-500 mr-2"></div>
                        <div class="w-3 h-3 rounded-full bg-green-500 mr-2"></div>
                        <span class="text-sm ml-2">Java</span>
                    </div>
                    <pre class="p-4 text-gray-200 overflow-x-auto"><code class="language-java">ArrayList&lt;String&gt; list = new ArrayList&lt;&gt;(Arrays.asList("a", "b", "c", "d"));
list.remove("c"); // 删除元素 "c"
System.out.println(list); // 输出 [a, b, d]</code></pre>
                </div>
            </div>

            <!-- Method 3 Details -->
            <div class="mb-12">
                <h3 class="text-2xl font-semibold mb-4 text-purple-700">3. 清空所有元素 (clear() 方法)</h3>
                <div class="bg-white rounded-lg overflow-hidden shadow-md p-6 mb-6 card">
                    <h4 class="text-lg font-semibold mb-3 text-gray-800">操作过程</h4>
                    <ul class="list-disc pl-6 space-y-2 text-gray-700">
                        <li><strong>清空列表</strong>：将 ArrayList 的 size 设置为 0，实际不会立即修改底层数组的大小，但会删除所有元素的引用。</li>
                        <li><strong>GC 处理</strong>：清空操作使得底层数组的元素引用变得不可达，这些元素可以被垃圾回收机制回收。</li>
                    </ul>
                </div>
                <div class="bg-white rounded-lg overflow-hidden shadow-md p-6 mb-6 card">
                    <h4 class="text-lg font-semibold mb-3 text-gray-800">性能影响</h4>
                    <ul class="list-disc pl-6 space-y-2 text-gray-700">
                        <li><strong>时间复杂度</strong>：O(n)，由于需要处理所有元素的引用（尽管底层数组不需要移动）。</li>
                        <li><strong>空间复杂度</strong>：O(1)，清空操作不会影响底层数组的大小，只是更新了 size。</li>
                    </ul>
                </div>
                <div class="bg-gray-800 rounded-lg overflow-hidden">
                    <div class="flex items-center px-4 py-2 bg-gray-700 text-gray-300">
                        <div class="w-3 h-3 rounded-full bg-red-500 mr-2"></div>
                        <div class="w-3 h-3 rounded-full bg-yellow-500 mr-2"></div>
                        <div class="w-3 h-3 rounded-full bg-green-500 mr-2"></div>
                        <span class="text-sm ml-2">Java</span>
                    </div>
                    <pre class="p-4 text-gray-200 overflow-x-auto"><code class="language-java">ArrayList&lt;String&gt; list = new ArrayList&lt;&gt;(Arrays.asList("a", "b", "c", "d"));
list.clear(); // 清空所有元素
System.out.println(list); // 输出 []</code></pre>
                </div>
            </div>
        </section>

        <!-- Source Code Analysis -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 section-title">源码分析</h2>
            <p class="text-gray-700 mb-8">下面我们将对 ArrayList 中删除数据的几个常用方法进行源码分析，重点关注 remove(int index), remove(Object o), 和 clear() 方法。我们将分析 JDK 1.8 的 ArrayList 源码，并探讨每个方法的实现细节。</p>

            <!-- Analysis 1 -->
            <div class="mb-12">
                <h3 class="text-2xl font-semibold mb-4 text-indigo-700">1. remove(int index) 方法源码分析</h3>
                <div class="bg-gray-800 rounded-lg overflow-hidden mb-6">
                    <div class="flex items-center px-4 py-2 bg-gray-700 text-gray-300">
                        <div class="w-3 h-3 rounded-full bg-red-500 mr-2"></div>
                        <div class="w-3 h-3 rounded-full bg-yellow-500 mr-2"></div>
                        <div class="w-3 h-3 rounded-full bg-green-500 mr-2"></div>
                        <span class="text-sm ml-2">Java</span>
                    </div>
                    <pre class="p-4 text-gray-200 overflow-x-auto"><code class="language-java">public E remove(int index) {
    rangeCheck(index); // 检查索引是否在有效范围内
    modCount++; // 记录修改次数，用于并发修改检查
    E oldValue = elementData[index]; // 记录要删除的元素
    int numMoved = size - index - 1; // 计算需要移动的元素数量
    if (numMoved > 0)
        System.arraycopy(elementData, index + 1, elementData, index, numMoved); // 移动元素
    elementData[--size] = null; // 清除最后一个元素的引用
    return oldValue; // 返回删除的元素
}</code></pre>
                </div>
                <div class="bg-white rounded-lg overflow-hidden shadow-md p-6 card">
                    <ul class="list-disc pl-6 space-y-2 text-gray-700">
                        <li><code>rangeCheck(index)</code>: 确保索引在有效范围内。如果索引无效，会抛出 IndexOutOfBoundsException。</li>
                        <li><code>modCount++</code>: 增加 modCount 用于支持 ArrayList 的 fail-fast 机制，防止在遍历期间数据结构被修改。</li>
                        <li><code>System.arraycopy</code>: 用于高效地将元素从一个位置移动到另一个位置。这个操作的时间复杂度为 O(n)，因为需要将所有后续元素右移一个位置。</li>
                        <li><code>elementData[--size] = null</code>: 清除被删除元素的引用，以帮助垃圾回收。</li>
                    </ul>
                </div>
            </div>

            <!-- Analysis 2 -->
            <div class="mb-12">
                <h3 class="text-2xl font-semibold mb-4 text-blue-700">2. remove(Object o) 方法源码分析</h3>
                <div class="bg-gray-800 rounded-lg overflow-hidden mb-6">
                    <div class="flex items-center px-4 py-2 bg-gray-700 text-gray-300">
                        <div class="w-3 h-3 rounded-full bg-red-500 mr-2"></div>
                        <div class="w-3 h-3 rounded-full bg-yellow-500 mr-2"></div>
                        <div class="w-3 h-3 rounded-full bg-green-500 mr-2"></div>
                        <span class="text-sm ml-2">Java</span>
                    </div>
                    <pre class="p-4 text-gray-200 overflow-x-auto"><code class="language-java">public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index + 1, elementData, index, numMoved);
    elementData[--size] = null;
}</code></pre>
                </div>
                <div class="bg-white rounded-lg overflow-hidden shadow-md p-6 card">
                    <ul class="list-disc pl-6 space-y-2 text-gray-700">
                        <li><strong>查找元素</strong>: 首先遍历 elementData 数组，查找匹配的元素。如果要删除的是 null 元素，则特别处理。</li>
                        <li><code>fastRemove(index)</code>: 一旦找到匹配的元素，调用 fastRemove 方法来删除元素，操作过程与 remove(int index) 方法相似。</li>
                        <li><strong>时间复杂度</strong>: 查找元素的时间复杂度为 O(n)，删除操作的时间复杂度为 O(n)，因此总体复杂度为 O(n)。</li>
                    </ul>
                </div>
            </div>

            <!-- Analysis 3 -->
            <div class="mb-12">
                <h3 class="text-2xl font-semibold mb-4 text-purple-700">3. clear() 方法源码分析</h3>
                <div class="bg-gray-800 rounded-lg overflow-hidden mb-6">
                    <div class="flex items-center px-4 py-2 bg-gray-700 text-gray-300">
                        <div class="w-3 h-3 rounded-full bg-red-500 mr-2"></div>
                        <div class="w-3 h-3 rounded-full bg-yellow-500 mr-2"></div>
                        <div class="w-3 h-3 rounded-full bg-green-500 mr-2"></div>
                        <span class="text-sm ml-2">Java</span>
                    </div>
                    <pre class="p-4 text-gray-200 overflow-x-auto"><code class="language-java">public void clear() {
    modCount++;
    for (int i = 0; i < size; i++)
        elementData[i] = null; // 清除元素的引用
    size = 0; // 重置大小
}</code></pre>
                </div>
                <div class="bg-white rounded-lg overflow-hidden shadow-md p-6 card">
                    <ul class="list-disc pl-6 space-y-2 text-gray-700">
                        <li><code>modCount++</code>: 更新修改次数，以支持 fail-fast 机制。</li>
                        <li><strong>清除引用</strong>: 遍历 elementData 数组，将每个元素的引用设为 null。这有助于垃圾回收器回收不再使用的对象。</li>
                        <li><code>size = 0</code>: 将 size 设置为 0，表示 ArrayList 已经清空。</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Performance Comparison -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-8 section-title">性能比较与优化建议</h2>
            <div class="grid md:grid-cols-2 gap-8">
                <div class="bg-white rounded-lg shadow-md p-6 card">
                    <h3 class="text-xl font-semibold mb-4 text-gray-800">数据结构选择指南</h3>
                    <div class="mermaid">
                        graph TD
                            A[频繁删除操作?] -->|是| B[考虑LinkedList]
                            A -->|否| C[ArrayList]
                            B --> D[需要随机访问?]
                            D -->|是| E[权衡性能需求]
                            D -->|否| F[优先LinkedList]
                            C --> G[主要进行随机访问和尾部操作]
                    </div>
                    <p class="mt-4 text-gray-600">根据具体使用场景选择最合适的数据结构，没有绝对的好坏之分</p>
                </div>
                <div class="bg-white rounded-lg shadow-md p-6 card">
                    <h3 class="text-xl font-semibold mb-4 text-gray-800">优化策略</h3>
                    <ul class="space-y-4">
                        <li class="flex items-start">
                            <div class="bg-indigo-100 p-2 rounded-full mr-4">
                                <i class="fas fa-lightbulb text-indigo-600"></i>
                            </div>
                            <div>
                                <h4 class="font-medium">批量删除优化</h4>
                                <p class="text-gray-600">将多个删除操作合并为一次批量操作，减少元素移动次数</p>
                            </div>
                        </li>
                        <li class="flex items-start">
                            <div class="bg-blue-100 p-2 rounded-full mr-4">
                                <i class="fas fa-arrows-alt-h text-blue-600"></i>
                            </div>
                            <div>
                                <h4 class="font-medium">反向遍历删除</h4>
                                <p class="text-gray-600">从后向前遍历可以避免删除时索引位置变化带来的问题</p>
                            </div>
                        </li>
                        <li class="flex items-start">
                            <div class="bg-purple-100 p-2 rounded-full mr-4">
                                <i class="fas fa-filter text-purple-600"></i>
                            </div>
                            <div>
                                <h4 class="font-medium">使用Iterator</h4>
                                <p class="text-gray-600">遍历时删除元素应使用Iterator.remove()方法，避免ConcurrentModificationException</p>
                            </div>
                        </li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Conclusion -->
        <section class="mb-16">
            <div class="bg-indigo-50 border border-indigo-100 rounded-lg p-8 card">
                <h2 class="text-2xl font-bold mb-4 text-indigo-800">总结</h2>
                <p class="text-gray-700 mb-4">
                    ArrayList的删除操作在特定场景下可能会成为性能瓶颈，特别是当需要在列表中间频繁删除元素时。
                    理解其底层实现原理有助于我们做出更明智的数据结构选择和应用优化策略。
                </p>
                <p class="text-gray-700">
                    在实际开发中，应当根据具体的使用场景选择最合适的数据结构。如果需要频繁在任意位置插入或删除元素，
                    LinkedList可能是更好的选择；如果主要进行随机访问和尾部操作，ArrayList则更为高效。
                </p>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-400 py-8">
        <div class="container mx-auto max-w-5xl px-4">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-white text-lg font-medium">技术小馆</h3>
                    <p class="text-sm">探索编程世界的奥秘</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="footer-link hover:text-gray-300 transition duration-300">
                        <i class="fas fa-globe mr-2"></i>http://www.yuque.com/jtostring
                    </a>
                </div>
            </div>
            <div class="border-t border-gray-800 mt-6 pt-6 text-sm text-center">
                &copy; 2023 技术小馆. 保留所有权利.
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```